import time
import socket
import bluetooth
import uuid

from DatabaseQueryTimer import DatabaseQueryTimer
from ProtocolParser import ProtocolParser


def setup_bluetooth_server():
    """
    初始化蓝牙服务器并开始监听客户端的连接请求。

    返回:
    - 已初始化的蓝牙服务器socket
    """

    # 创建一个RFCOMM协议的蓝牙socket
    server_sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)

    # 使用任何可用的端口
    port = bluetooth.PORT_ANY
    server_sock.bind(("", port))
    server_sock.listen(1)

    # 生成一个UUID作为服务标识，并进行服务广告
    service_uuid = str(uuid.uuid4())
    bluetooth.advertise_service(
        server_sock,
        "SampleServer",
        service_id=service_uuid,
        service_classes=[bluetooth.SERIAL_PORT_CLASS],
        profiles=[bluetooth.SERIAL_PORT_PROFILE],
    )

    print(f"正在RFCOMM通道 {port} 上等待连接...")
    return server_sock


def send_data_to_client(client_sock, data_hex_str):
    """
    向客户端发送16进制字符串表示的数据。

    参数:
    - client_sock: 客户端的socket连接
    - data_hex_str: 代表数据的16进制字符串
    """
    # 将16进制字符串转换为字节数据
    data_bytes = bytes.fromhex(data_hex_str)
    client_sock.send(data_bytes)
    print(f"已发送{data_bytes[2]}数据: {data_hex_str}")


def bytes_to_hex_string_with_spaces(byte_data):
    # 使用 hex 函数将 bytes 转换为 16 进制字符串，并去掉前缀 '0x'，然后使用空格连接每两个字符
    hex_string = ' '.join(hex(byte)[2:].zfill(2) for byte in byte_data)
    return hex_string


def handle_client_connection(client_sock):
    """
    处理与客户端的连接，读取数据并输出。

    参数:
    - client_sock: 客户端的socket连接
    """
    timer = DatabaseQueryTimer()
    try:
        while True:
            data = client_sock.recv(1024)
            # 检查数据，如果没有则断开连接
            if not data:
                timer.control_callback("stop")
                time.sleep(1)
                print('蓝牙连接已断开')
                break
                # 检查蓝牙连接是否仍然存在
                # if is_connection_alive(client_sock):
                #     print('接收到空数据（可能连接已断开），继续等待数据中')
                # else:
                #     print('连接已断开')
                #     break
                # continue

            # 打印接收到的数据
            hex_data = " ".join([f"{byte:02x}" for byte in data])
            print(f"接收到的数据: {hex_data.upper()}")
            if data[4] == 0x05 and (len(data) - 4) == data[3]:
                hex_str = '75 80 01 0A 05 00 66 55 44 33 22 11 0C E7'
                send_data_to_client(client_sock, hex_str)

                parser = ProtocolParser()
                info_id, level = parser.parse(data)
                timer.control_callback("stop")
                timer.check_id = None
                time.sleep(2)
                timer.control_callback("start", info_id, client_sock, level)
            elif data[4] == 0x01 and data[5] == 0x01:
                hex_str = '75 80 01 19 01 01 11 22 33 44 55 66 03 01 01 70 19 31 12 99 20 11 22 33 44 55 66 1B E7'
                send_data_to_client(client_sock, hex_str)
            elif data[4] == 0x06 or data[4] == 0x07:
                result = bytearray(data)  # 将字节串转换为可变字节数组
                result[1] = 0x80
                b = bytes(result)
                client_sock.send(b)
                print(f"{b[2]} 已发送数据: {bytes_to_hex_string_with_spaces(b).upper()}\n")

            if data[4] == 0x07 and data[5] == 0x03 and (len(data) - 4) == data[3]:
                timer.control_callback("stop")
    except OSError as e:
        print(f"连接错误: {e}")
    finally:
        print("执行结束，连接已关闭。")
        client_sock.close()


def is_connection_alive(sock):
    """
    检查给定的socket连接是否仍然活跃。

    参数:
    - sock: 要检查的socket对象

    返回:
    - 布尔值，表示连接是否活跃
    """
    try:
        # 一种常用的方法是尝试对socket进行非阻塞的发送操作
        # 如果发送失败，说明连接可能已经断开
        sock.setblocking(0)
        sock.send(b'')
    except socket.error:
        # 发送失败，连接可能已经断开
        return False
    finally:
        sock.setblocking(1)
    return True
